﻿using System.Collections;
using System.Xml;
using Narau.Required_interfaces;

namespace Narau.Common
{
    class Tema 
    {
        private Tema             m_Parent;
        private ArrayList        m_ChildList;
        private string           m_Name;
        private string           m_DataText;
        private ArrayList        m_MondaiList;
        private string           m_UID;
        private int              m_iNumTotales = 0;
        private int              m_iNumCompletos = 0;
        private ReqIntf_TreeNode m_ri_TreeNode;

        public int Total { get { return m_iNumTotales; } }
        public int Good  { get { return m_iNumCompletos; } }

        public string StrUID { get { return m_UID; } }
        public string Info   { get { return m_DataText; } set { m_DataText = value; } }
        public string Title
        { 
            set
            {
                m_Name = value;
                if (m_ri_TreeNode != null)
                {
                    m_ri_TreeNode.SetNameString(value);
                }
            }
        }

        public string FullName
        {
            get
            {
                string complete_name = "";

                ArrayList tema_branch = new ArrayList();

                tema_branch.Add(m_Name);
                Tema itTema = m_Parent;
                while (itTema != null)
                {
                    tema_branch.Add(itTema.m_Name);
                    itTema = itTema.m_Parent;
                }

                for (int i = tema_branch.Count - 1; i >= 0; i--)
                {
                    complete_name += tema_branch[i] as string + (i == 0 ? "" : "   /   ");
                }

                return complete_name;
            }
        }
        
        //--------------
        // Constructor
        //--------------
        public Tema(Tema tema_parent, ReqIntf_TreeNode tree_node)
        {
            m_MondaiList = new ArrayList();
            m_ChildList = new ArrayList();
            
            m_ri_TreeNode = tree_node;
            m_ri_TreeNode.LinkedObject = this;

            m_Parent = tema_parent;
            if(tema_parent != null)
            {
                tema_parent.AddChild(this);
            }
        }

        //------------------------------------
        // Añade un tema a la lista de hijos
        //------------------------------------
        private void AddChild(Tema tema)
        {
            m_ChildList.Add(tema);
        }

        //--------------------------------------------------------------------
        // Añade un ejercicio que trata el tema actual (lo tiene en su lista
        // de temas definida en el xml)
        //--------------------------------------------------------------------
        public void AddMondai(Mondai ejercicio)
        {
            m_MondaiList.Add(ejercicio);
        }

        //-------------------------------------------------
        // Parsea el XML con el tag de <tema> ... </tema>
        //-------------------------------------------------
        public virtual void ParserXML(XmlNode tema_node_xml)
        {
            XmlAttribute xml_attr_clas = tema_node_xml.Attributes["nom"];
            if (xml_attr_clas != null)
            {
                Title = xml_attr_clas.Value;
            }
            else
            {
                Title = "[sin nombre]";
            }            

            XmlAttribute xml_attr_str = tema_node_xml.Attributes["str"];
            if (xml_attr_str != null)
            {
                m_DataText = xml_attr_str.Value;
            }
            else
            {
                m_DataText = "[vacío]";
            }

            XmlAttribute xml_attr_uid = tema_node_xml.Attributes["uid"];
            if (xml_attr_uid != null)
            {
                m_UID = xml_attr_uid.Value;
            }
            else
            {
                m_UID = "BAD-UID";
            }
        }

        //-----------------------------------------------------------------------------------------------------
        // Para construir exámenes buscando ejercicios a partir de una busqueda en el tema actual y sus hijos
        //-----------------------------------------------------------------------------------------------------
        public void BuildShiken(ShikenGenerator shikenGen)
        {
            foreach (Mondai itMondai in m_MondaiList)
            {
                shikenGen.AddMondai(itMondai);
            }
            foreach (Tema itTema in m_ChildList)
            {
                itTema.BuildShiken(shikenGen);
            }
        }

        //---------------------------------------------
        // Acceso publico al updateo de datos de rama
        //---------------------------------------------
        public void UpdateData()
        {
            GetNumMondaiTotal(); 
            GetNumMondaiChecked();
            UpdateTreeNode();
        }

        //---------------------------------------
        // Actualización de los datos del arbol
        //---------------------------------------
        private void UpdateTreeNode()
        {
            string data_tree_node;

            data_tree_node = "(" + m_iNumCompletos + "/" + m_iNumTotales + ")";
            m_ri_TreeNode.SetDataString(data_tree_node);

            foreach (Tema itChildTema in m_ChildList)
            {
                itChildTema.UpdateTreeNode();
            }
        }

        //-------------------------------
        // Recursiva en los temas hijos
        //-------------------------------
        private int GetNumMondaiTotal()
        {
            m_iNumTotales = m_MondaiList.Count;

            foreach(Tema itChildTema in m_ChildList)
            {
                m_iNumTotales += itChildTema.GetNumMondaiTotal();
            }

            return m_iNumTotales;
        }

        //-------------------------------
        // Recursiva en los temas hijos
        //-------------------------------
        private int GetNumMondaiChecked()
        {
            m_iNumCompletos = 0;
            foreach (Mondai itEjercicio in m_MondaiList)
            {
                if (itEjercicio.IsOK())
                {
                    m_iNumCompletos++;
                }
            }

            foreach (Tema itChildTema in m_ChildList)
            {
                m_iNumCompletos += itChildTema.GetNumMondaiChecked();
            }

            return m_iNumCompletos;
        }
    }
}
